Hallo, guten Morgen.

Mit dem Skript, ich habe die vorhin reingegeben, es kann sein, dass sie nicht ganz ausreichen.

Christoph kommt nachher nochmal nach, er hatte vorhin ein Druckerproblem und ich denke so in 10 Minuten oder so,

kommt dann auf jeden Fall der Rest davon.

Ich bin das letzte Mal auch nicht ganz fertig geworden, deswegen setze ich auch an der Stelle nochmal auf.

Wir waren irgendwo so im hinteren Teil der kritischen Abschnitte und dann ging es noch so um

Lebendigkeitsbedingungen von Prozessen, das hatten wir noch nicht besprochen.

Ich will einfach nochmal an den kritischen Abschnitten aufsetzen, also letztendlich kritische Abschnitte,

die irgendwelche Programmabschnitte, die eben letztendlich von gleichzeitig Prozessen nicht parallel ausgeführt werden dürfen,

sollen sich zueinander eben verhalten, als wenn sie unthalbar sind, weil eben eine Aktivität, die im kritischen Abschnitt ist,

also nicht unterbrochen werden kann von einer anderen.

Ich unterscheide an der Stelle nochmal die unthalbaren kritischen Abschnitte, also die nicht gemeinsam von mehreren Prozessen durchlaufen werden können,

die also blockieren, synchronisiert werden müssen und eben von gleichzeitigem Prozess nur sequenziell durchlaufen werden können,

also erst der eine, dann der andere.

Teilbare kritische Abschnitte oder gemeinsam durchlaufbare kritische Abschnitte

ist ein bisschen ein Streitpunkt an der Stelle auch.

Wosch hat das so mal definiert, es gibt also auch Leute, die sagen, das ist ein Widerspruch in sich, also irgendwie so eine Art schwarzer Schimmel oder so,

weil kritische Abschnitte eben von der Definition her nicht gemeinsam durchlaufbar sein dürfen und können.

Im Hinblick auf nicht blockierende Synchronisation, wenn man also jetzt nicht die Fragestellung betrachtet,

dürfen da mehrere Fretz gleichzeitig drin sein, sondern nur die Fragestellung betrachtet,

was kommt am Ende an letztendlich korrekten Ergebnis raus.

Dann meint Wosch an der Stelle eben, da kann man durchaus eben auch kritische Abschnitte betrachten, die dann doch eben gegebenenfalls eben von mehreren Fretz durchlaufen werden können,

bei denen aber wenn es zum Konflikt kommt eben eventuell dann ein Fretz auch mal zurückgesetzt werden muss.

Ich weiß nicht, wo fehlen noch Skripten, dass ich mal, Christoph so weiter links drüben fehlt vor allem was, so die Ecke.

Christoph? Da drüben, ja. Und am Schluss da oben, ja.

Dann ist die Frage eben, wie durchläuft man nun kritische Abschnitte? Das Wesentliche sind also die Enter- und Lieferparationen, dafür gibt es dann Protokolle,

was muss eben getan werden, wenn ein kritischer Abschnitt betreten wird?

Üblicherweise ist also das Eintrittsprotokoll so, dass eben damit ein Prozessor ein Fretz eben den kritischen Abschnitt betreten darf.

Wenn der Abschnitt bereits betreten ist, also bereits belegt ist, dann gibt es also zwei Möglichkeiten.

Entweder man blockiert an der Stelle, das heißt also der zweite Prozess, der den kritischen Abschnitt betreten will, muss warten.

Oder man macht es eben nicht blockierend, das heißt man darf den Prozess, der den kritischen Abschnitt bereits betreten hat, überlappen,

muss dann aber eventuell eben sich darum kümmern, wenn es dann eben zu Zugriffskonflikten kommt, wie man die regelt.

Das Austrittsprotokoll aus dem kritischen Abschnitt regelt also die Freigabe.

Im blockierenden Fall heißt es also, dass man einen Prozess, der wartet, hintangestellt wurde, eben deblockiert.

Und im nicht blockierenden Fall kann es also sein, dass man den überlappten Prozess gegebenenfalls eben zurücksetzen muss, damit er wiederholt wird.

Das war also dieses Bildchen, das ich hatte, also wenn das der kritische Abschnitt ist.

Im blockierenden Fall, also der erste Thread kommt, der kritische Abschnitt ist frei, er darf durchlaufen.

Wenn, während er gerade drin ist, ein zweiter Thread kommt, dann muss er hier warten.

Und erst wenn der hier den kritischen Abschnitt verlässt zu diesem Zeitpunkt, deblockiert er den und dann darf der betreten.

Das wäre der Ablauf und der überlappte Ablauf wäre eben so, der erste Thread läuft rein, das ist wunderbar.

Der zweite Thread kommt, läuft auch rein.

So, und jetzt nehmen wir mal an, es gab irgendwie einen Prozesswechsel oder aufgrund von irgendwelchen Verzögerungen ist der erste langsam,

der zweite kann tatsächlich durchlaufen, er überholt ihn quasi.

So, dann muss er hier an dieser Stelle im Endeffekt entschieden werden.

Haben wir jetzt irgendwas kaputt gemacht, dadurch, dass wir gemeinsam drin waren.

Und wenn wir das feststellen, also zum Beispiel, der hier hat irgendwelche Register gelesen und will jetzt auf diesen Registern operieren

und was zurückschreiben und hat einen inkonsistenten Zustand dadurch, weil der diese Register auch, also den entsprechenden Speichersteller auch gelesen hat,

modifiziert hat und zurückgeschrieben hat und der hat im Register jetzt letztendlich einen alten Wert, auf den er weiterrechnen würde,

dann muss der zurückgesetzt werden, dass er letztendlich nochmal neu aus dem Speicher liest

und den Wert, den der hier reingeschrieben hat, neu aufnimmt und damit dann halt nochmal durchläuft.